// 统一的API请求模块
const BASE_URL = 'http://localhost:8000';

/**
 * 发送API请求的通用方法
 * @param {string} url - 请求路径
 * @param {string} method - 请求方法
 * @param {Object} data - 请求数据
 * @param {boolean} showLoading - 是否显示加载提示
 * @param {string} loadingTitle - 加载提示文本
 * @returns {Promise} 返回请求结果的Promise
 */
// 通用请求函数
function request(url, method, data = {}, showLoading = true, loadingTitle = '加载中...') {
    return new Promise((resolve, reject) => {
        if (showLoading) {
            uni.showLoading({
                title: loadingTitle,
                mask: true
            });
        }

        uni.request({
            url: BASE_URL + url,
            method: method,
            data: data,
            timeout: 120000, // 设置120秒超时，适应长对话场景
            header: {
                'content-type': 'application/json'
            },
            success: (res) => {
                if (showLoading) {
                    uni.hideLoading();
                }
                console.log('API请求成功:', url, res.data);
                resolve(res.data);
            },
            fail: (err) => {
                if (showLoading) {
                    uni.hideLoading();
                }
                console.error('API请求失败:', url, err);
                
                // 细化错误提示
                let errorMsg = '网络请求失败，请检查网络连接';
                if (err.errMsg && err.errMsg.includes('timeout')) {
                    errorMsg = '请求超时，请稍后重试';
                } else if (err.errMsg && err.errMsg.includes('fail')) {
                    errorMsg = '网络连接失败，请检查网络设置';
                }
                
                uni.showToast({
                    title: errorMsg,
                    icon: 'none',
                    duration: 3000
                });
                reject(err);
            }
        });
    });
}

/**
 * 发送验证码
 * @param {string} email - 邮箱地址
 * @returns {Promise}
 */
export function sendVerificationCode(email) {
    return request(
        '/send_Ver_code',
        'post',
        {
			email:email
		},
    )
}

/**
 * 用户注册
 * @param {string} email - 邮箱地址
 * @param {string} password - 密码
 * @param {string} code - 验证码
 * @param {string} user_name - 用户名（可选）
 * @returns {Promise}
 */
export function register(email, password, code, user_name) {
  // 注意：需要将所有参数作为查询参数传递，而不是请求体
  // 同时确保code是字符串，确保与后端存储的类型匹配
  const codeStr = String(code);
  let url = `/sinup?email=${encodeURIComponent(email)}&pwd=${encodeURIComponent(password)}&code=${encodeURIComponent(codeStr)}`;
  
  // 始终传递user_name参数，即使为空字符串，这样后端才能正确处理
  url += `&user_name=${encodeURIComponent(user_name || '')}`;
  
  return request(url, 'POST', {}, true, '注册中...');
}

/**
 * 用户登录
 * @param {string} account - 账户（邮箱或用户名）
 * @param {string} password - 密码
 * @returns {Promise}
 */
export function login(account, password) {
  return request('/login', 'POST', { account, pwd: password }, true, '登录中...');
}

/**
 * 发送聊天消息（流式）
 * @param {number} user_id - 用户ID
 * @param {string} question - 用户的问题
 * @param {number} subjectid - 主题ID，0表示创建新主题
 * @returns {Promise} 包含回调函数的Promise
 */
export function streamChat(user_id, question, subjectid = 0, onMessage = null, onComplete = null) {
  return new Promise((resolve, reject) => {
    try {
      // 构建请求URL，确保所有参数正确编码
      const url = `${BASE_URL}/stream_chat?user_id=${user_id}&question=${encodeURIComponent(question)}&subjectid=${subjectid}`;
      console.log(`发起流式聊天请求: ${url}`);
      
      let currentSubjectId = subjectid;
      let responseContent = '';
      let hasReceivedSubjectId = false;
      let accumulatedContent = '';
      
      // 使用更通用的方式处理，不依赖onData方法
      uni.request({
        url: url,
        method: 'GET',
        header: {
          'Content-Type': 'application/json',
          'Accept': 'text/event-stream'
        },
        timeout: 120000, // 设置120秒超时，适应长对话场景
        success: (res) => {
          console.log('请求成功，状态码:', res.statusCode);
          
          // 即使不是流式响应，我们也尝试处理完整响应
          if (res.statusCode === 200 && res.data) {
            try {
              let data = res.data.toString();
              console.log('接收到完整响应数据');
              
              // 检查是否包含错误信息
              if (data.startsWith('错误:') || data.includes('错误:')) {
                const errorMsg = data.replace(/^\d+/, '').trim();
                console.error('接收到错误信息:', errorMsg);
                reject(new Error(errorMsg));
                return;
              }
              
              // 处理接收到的数据
              // 如果是新主题，响应开头会是主题ID
              if (subjectid === 0 && !hasReceivedSubjectId) {
                // 查找第一个非数字字符的位置
                const firstNonDigitMatch = data.match(/\D/);
                if (firstNonDigitMatch && firstNonDigitMatch.index > 0) {
                  const potentialSubjectId = parseInt(data.substring(0, firstNonDigitMatch.index));
                  if (!isNaN(potentialSubjectId)) {
                    currentSubjectId = potentialSubjectId;
                    hasReceivedSubjectId = true;
                    // 剩余部分是回复内容
                    data = data.substring(firstNonDigitMatch.index);
                    
                    // 调用回调函数通知新的主题ID
                    if (onMessage) {
                      onMessage('', '', currentSubjectId);
                    }
                  }
                }
              }
              
              responseContent = data;
              
              // 实现流式显示：一个字一个字地显示
              let currentIndex = 0;
              const displayInterval = setInterval(() => {
                if (currentIndex < responseContent.length) {
                  accumulatedContent += responseContent[currentIndex];
                  currentIndex++;
                  
                  // 调用回调函数，传递当前累积的内容
                  if (onMessage) {
                    onMessage(responseContent[currentIndex - 1], accumulatedContent, currentSubjectId);
                  }
                } else {
                  clearInterval(displayInterval);
                  
                  // 完成回调
                  if (onComplete) {
                    onComplete(accumulatedContent, currentSubjectId);
                  }
                  
                  resolve({
                    content: accumulatedContent,
                    subjectId: currentSubjectId
                  });
                }
              }, 50); // 每50毫秒显示一个字
            } catch (error) {
              console.error('处理响应数据时出错:', error);
              reject(error);
            }
          } else {
            reject(new Error(`请求失败，状态码: ${res.statusCode}`));
          }
        },
        fail: (err) => {
          console.error('请求失败:', err);
          reject(err);
        }
      });
    } catch (error) {
      console.error('发起请求时出错:', error);
      reject(error);
    }
  });
}

// 获取用户的历史对话主题列表
export function getSubjects(user_id) {
  console.log('调用getSubjects，用户ID:', user_id);
  return request(
     `/get_subjects?user_id=${user_id}`,
    'GET', 
	{},
	true, 
	'加载历史对话...');
}

// 获取特定主题的对话内容
export function getChatHistory(user_id, subject_id) {
  console.log('调用getChatHistory，用户ID:', user_id, '主题ID:', subject_id);
  return request(
    `/get_chat_history?user_id=${user_id}&subject_id=${subject_id}`,
    'GET',
	{}, 
	true, 
	'加载对话内容...');
}

// 修改密码
export function changePassword(email, newPassword, code) {
    return request(
        '/pwd_change',
        'post',
        {
            email: email,
            newpwd: newPassword,
            code: code
        }
    )
}

// 修改用户名
export function changeUsername(user_id, user_name) {
    return request(
            '/uname_change', 
            'POST', 
            { 
                user_id: user_id, 
                user_name: user_name 
            },
        )
}

// 获取用户列表
export function getUsers() {
  return request('/users', 'GET', {}, true, '加载用户列表...');
}

// 删除用户
export function deleteUser(user_id) {
  return request(
     `/delete_user?user_id=${user_id}`,
     'DELETE',
	 {}, 
	 true, 
	 '删除用户中...');
}

// 更新用户信息
export function updateUser(user_id, user_name = null, email = null) {
  const data = { user_id };
  if (user_name !== null) data.user_name = user_name;
  if (email !== null) data.email = email;
  
  return request(
     '/update_user',
     'POST',
	 {
		 data: data,
	}, 
	true, 
	'更新用户信息中...');
}

// 删除历史对话主题及所有对话内容
export function deleteSubject(user_id, subject_id) {
  console.log('调用deleteSubject，用户ID:', user_id, '主题ID:', subject_id);
  return request({	
    url: `/delete_subject?user_id=${user_id}&subject_id=${subject_id}`,
    method: 'DELETE'
  }, true, '删除中...');
}
